home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Development / General / Controls GH / Slider Control GH / Slider.c < prev    next >
C/C++ Source or Header  |  1993-10-22  |  18KB  |  659 lines
  1. /************** Slider.c v1.0 *********
  2. ******* code for a slider type control CDEF
  3. *******©1993 Glenn R. Howes
  4. ******* all rights reserved *****/
  5. // #include "Slider.h" included in the prefix option
  6.  
  7. #include "utilities.h"
  8. pascal long main(short variation, ControlHandle me,
  9.                 short msg, long param)
  10. {
  11.     long result = 0L;
  12.  
  13.  
  14.     switch (msg)
  15.     {
  16.         case testCntl: // determine if mouse down is in control
  17.             result = TestMe(me, HiWord(param), LoWord(param));
  18.         break;
  19.         case calcCRgns: // 24-bit means of requesting shape of control or part
  20.             result = CalcStripRegion(me, (RgnHandle)param);
  21.         break;
  22.         case initCntl: // 1st message, allocate private data
  23.             InitMe(me);
  24.         break;
  25.         case dispCntl: // last message, dispose private data
  26.             if ((*me)->contrlData)
  27.                 DisposeHandle((*me)->contrlData);
  28.         break;
  29.         case posCntl: // given new point (and old point from the thumbCntl msg)
  30.                     // set the controls new value
  31.             PositionMe(me, HiWord(param), LoWord(param));
  32.         break;
  33.         case thumbCntl: // request for info for use in dragging thumb outline
  34.                         // also gives point at which drag starts
  35.             ProvideDragInfo(me, (ThumbInfo*)param);
  36.         break;
  37.         case dragCntl: // we aren't doing any custom tracking ignore
  38.         break;
  39.         case autoTrack: // we aren't doing any custom tracking ignore
  40.             // result = TrackMe(me, LoWord(param));
  41.         break;
  42.         case calcCntlRgn: // 32-bit clean message asking for whole cntl region
  43.             CalcRegion( me, (RgnHandle)param, FALSE);
  44.             result = 1L;
  45.         break;
  46.         case calcThumbRgn: // 32-bit clean message asking for shape of thumb
  47.             result =  CalcRegion( me, (RgnHandle)param, TRUE);
  48.             result =  1L;
  49.         break;
  50.         case drawCntl: // draw control or part of control
  51.             DrawMe(me, LoWord(param));
  52.         break;
  53.     }
  54.     
  55.     
  56.     return (result);
  57. }
  58. /******************* ProvideDragInfo ***********
  59. **** a mouse down has occurred in the thumb and we are
  60. **** asked to proide information used by the toolbox routine
  61. **** DragGrayRgn to confine the drag to a given rectangle 
  62. ****  the limit rect is the rect in which the region will move
  63. ****  the slop rect is the rect in which the mouse can be and the
  64. ****  gray outline will still be visible.
  65. ****  Notice that I'm taking into account the position within the
  66. ****  thumb so that the region doesn't go beyond the control****/
  67. void ProvideDragInfo(ControlHandle me, ThumbInfo *param)
  68. { 
  69.     Rect            ctlRect, thumbRect;
  70.     PrivateHandle    privData;
  71.     Point            entry;
  72.     privData = (PrivateHandle)(*me)->contrlData;
  73.     
  74.     // the original mousedown point is stored in the top,left corner of
  75.     // the thumbinfo's limitRect field
  76.     
  77.     entry.h = param->limitRect.left;
  78.     entry.v = param->limitRect.top;
  79.     if (privData)
  80.     {
  81.         (*privData)->entryPoint.h = entry.h;
  82.         (*privData)->entryPoint.v = entry.v;
  83.     }
  84.     CopyRect(&(*me)->contrlRect, &ctlRect);
  85.     CalcThumbRects(me, (*me)->contrlValue, &thumbRect);
  86.     
  87.     if ((ctlRect.bottom - ctlRect.top) // if we are a vertical control
  88.         >= (ctlRect.right - ctlRect.left))
  89.     {
  90.         ctlRect.bottom -= (thumbRect.bottom - entry.v);
  91.         ctlRect.top += (entry.v - thumbRect.top);
  92.         
  93.         CopyRect(&ctlRect, ¶m->limitRect);
  94.     
  95.         param->axis = 2; // confine to vertical
  96.     }
  97.     else // if we are a horizontal control
  98.     {
  99.         ctlRect.right -= (thumbRect.right - entry.h) -1;
  100.         ctlRect.left += (entry.h - thumbRect.left);
  101.         
  102.         CopyRect(&ctlRect, ¶m->limitRect);
  103.     
  104.         param->axis = 1; // confine to horizontal
  105.  
  106.     }
  107.     InsetRect(&ctlRect, -5, -5); // make slop bigger than ctl rect
  108.     CopyRect(&ctlRect, ¶m->slopRect);
  109. }
  110. /************ PositionMe *************
  111. ******** I've been dragged, with the sequence 
  112. ****** TestMe, ProvideDragInfo, and now PositionMe
  113. ****** so the delta values are changes from the original mousedown *****/
  114. void PositionMe(ControlHandle me, short deltaV, short deltaH)
  115. {
  116.     Point    newPoint;
  117.     
  118.     MapValue2Point(me, (*me)->contrlValue, &newPoint);
  119.     newPoint.v += deltaV;
  120.     newPoint.h += deltaH;
  121.     
  122.     MapPt2Value(me, &newPoint, &(*me)->contrlValue);
  123.     DrawMe(me, 0);
  124. }
  125. /************ MapPt2Value *****************
  126. ***** given a point within the control, map it to a control value
  127. ******/
  128. void MapPt2Value(ControlHandle me, Point *aPoint, short *value)
  129. {
  130.     Rect    ctlRect;
  131.     short    width, height, thumbLen, halfThumb;
  132.     long    min, max, locValue;
  133.     
  134.     CopyRect(&(*me)->contrlRect, &ctlRect);
  135.     min = (*me)->contrlMin;
  136.     max = (*me)->contrlMax;
  137.     
  138.     width = ctlRect.right - ctlRect.left;
  139.     height = ctlRect.bottom - ctlRect.top;
  140.     
  141.     thumbLen = CalcThumbLen(&ctlRect);
  142.     halfThumb = thumbLen /2;
  143.     
  144.     if (width > height)
  145.     {
  146.         ctlRect.right -= halfThumb;
  147.         ctlRect.left += halfThumb;
  148.         width -= thumbLen;
  149.         if (ctlRect.right < aPoint->h) aPoint->h = ctlRect.right;
  150.         else if (ctlRect.left > aPoint->h) aPoint->h = ctlRect.left;
  151.     
  152.         locValue = min + ((max-min)*(aPoint->h-ctlRect.left))/width;
  153.     }
  154.     else
  155.     {
  156.         ctlRect.bottom -= halfThumb;
  157.         ctlRect.top += halfThumb;
  158.         height -= thumbLen;
  159.         if (ctlRect.bottom < aPoint->v) aPoint->v = ctlRect.bottom;
  160.         else if (ctlRect.top > aPoint->v) aPoint->v = ctlRect.top;
  161.         
  162.         locValue = min + ((max-min)*(ctlRect.bottom-aPoint->v))/height;
  163.     }
  164.     *value = locValue;
  165. }
  166. /*********** MapValue2Point *********
  167. ******* given a control value, convert it to a point within
  168. ******* the control corresponding to where the center of the thumb
  169. ******* must be **********/
  170. void MapValue2Point(ControlHandle me, short value, Point *aPoint)
  171. {
  172.     Rect    ctlRect;
  173.     long    width, height;
  174.     long    min, max;
  175.     short    thumbLen, halfThumb;
  176.     CopyRect(&(*me)->contrlRect, &ctlRect);
  177.     min = (*me)->contrlMin;
  178.     max = (*me)->contrlMax;
  179.     
  180.     thumbLen = CalcThumbLen(&ctlRect);
  181.     halfThumb = thumbLen /2;
  182.     
  183.     width = ctlRect.right - ctlRect.left;
  184.     height = ctlRect.bottom - ctlRect.top;
  185.     
  186.     if (value > max)
  187.         value = max;
  188.     else if (value < min) 
  189.         value = min;
  190.  
  191.     if (width > height) // horizontal control
  192.     {
  193.         width -= thumbLen;
  194.         aPoint->h = ctlRect.left + halfThumb + (width*value)/(max-min);
  195.         aPoint->v = ctlRect.top + height/2;
  196.     }
  197.     else
  198.     {
  199.         height -= thumbLen;
  200.         aPoint->v = ctlRect.bottom - halfThumb -(height * value)/(max-min);
  201.         aPoint->h = ctlRect.left + width/2;
  202.     }
  203. }
  204.  
  205. /************* CalcStripRegion *******
  206. ******* when in 24-bit mode, we will get a region handle whose
  207. ******* 31st bit is used to indicate if the app wants the region
  208. ******* of the thumb (on) or the whole control (off).
  209. ******* We are supposed to strip off the bit and return the 
  210. ******* calculated region ******/
  211. long CalcStripRegion(ControlHandle me, RgnHandle theRegion)
  212. {
  213.     char    calcThumb;
  214.     if (Using32Bit()) // WHY IS THIS GETTING CALLED¿
  215.     {
  216.         return (CalcRegion(me, theRegion, FALSE));
  217.     }
  218.     else
  219.     {
  220.         calcThumb = (long)theRegion >> 31L; // getting high bit, on = calc thumb
  221.         theRegion = (RgnHandle)(0x7FFFFFFFL & (long)theRegion); 
  222.         // stripping out high bit only see tech note “joy of 32 bit clean”
  223.         return (CalcRegion(me, theRegion, calcThumb)); // calc the region
  224.     }
  225. }
  226. /*************** CalcRegion ******
  227. ******* figure the region of the control, or the thumb if the 
  228. ******* calcThumb parameter is non-zero **********/
  229. long CalcRegion(ControlHandle me, RgnHandle theRegion, char calcThumb)
  230. {
  231.     RgnHandle    myRegion;
  232.     Rect        ctlRect, thumbRect;
  233.     short        diameter;
  234.     myRegion = NewRgn();
  235.     if (myRegion)
  236.     {
  237.         OpenRgn();
  238.         CopyRect(&(*me)->contrlRect, &ctlRect);
  239.         diameter = CalcRounding(&ctlRect);
  240.         if (calcThumb)
  241.         {
  242.             CalcThumbRects(me, (*me)->contrlValue, &thumbRect);
  243.             FrameRoundRect(&thumbRect, diameter,diameter);
  244.         }
  245.         else
  246.         {
  247.             FrameRoundRect(&ctlRect, diameter, diameter);
  248.         }
  249.  
  250.         CloseRgn(myRegion);
  251.         InsetRgn(myRegion, -1, -1); // make it a little bigger to take into account
  252.                                     // width of lines
  253.         UnionRgn(theRegion, myRegion, theRegion);
  254.         DisposeRgn(myRegion);
  255.     }
  256.     
  257.     return ((long)theRegion);
  258. }
  259. /************ TestMe ****************
  260. ******* is the point within the control, and if so,
  261. ******* what part, there are 3 parts: thumb, pageup, 
  262. pagedown **********/
  263. long TestMe(ControlHandle me, short v, short h)
  264. {
  265.     Point            testPoint;
  266.     long            result = 0L;
  267.     Rect            ctlRect, whiteRect, grayRect, roundThumb;
  268.     
  269.     testPoint.h = h; testPoint.v = v;
  270.     
  271.     if(PtInRect(testPoint, &(*me)->contrlRect) && (*me)->contrlHilite < 255) 
  272.     // quick determination of (mouse in rect and control undimmed)
  273.     {
  274.         CopyRect(&(*me)->contrlRect, &ctlRect);
  275.         CalcGrayRect(me, &grayRect, &whiteRect);
  276.         CalcThumbRects(me,(*me)->contrlValue, &roundThumb);
  277.         if (PtInRect(testPoint, &roundThumb))
  278.         {
  279.             result = inThumb;
  280.         }
  281.         else if (PtInRect(testPoint, &grayRect))
  282.         {
  283.             result = inPageUp;
  284.         }
  285.         else
  286.         {
  287.             result = inPageDown;
  288.         }
  289.     }
  290.     return (result);
  291. }
  292. /*************** DrawMe **********
  293. ******* Draw the control or the control's thumb *****/
  294. void DrawMe(ControlHandle me, short part)
  295. {
  296.     Rect            grayRect, whiteRect, thumbRect, tempRect;
  297.     PenState        oldState;
  298.     PrivateHandle    privData;
  299.     RgnHandle        oldRegion = 0L, thumbRegion = 0L, ctlRegion =0L;
  300.     short            diameter;
  301.     
  302.     GetPenState(&oldState);
  303.     PenNormal();
  304.     privData = (PrivateHandle)(*me)->contrlData;
  305.     CalcGrayRect(me, &grayRect, &whiteRect);
  306.     CalcThumbRects(me, (*me)->contrlValue, &thumbRect);
  307.  
  308.     switch (part)
  309.     {
  310.         case 255: // change in dimming
  311.             EraseRect(&grayRect);
  312.         case 0: // draw whole thing
  313.             EraseRect(&whiteRect);
  314.             DrawMyFrame(me,&grayRect);
  315.             DrawMyIndicator(me, &thumbRect);
  316.         break;
  317.         case 129: // redraw generic indicator
  318.                 // I'm using the regions to stop the flashing of drawing 
  319.                 // the gray rect and then drawing the white thumb over it
  320.             oldRegion = NewRgn();
  321.             thumbRegion = NewRgn();
  322.             ctlRegion = NewRgn();
  323.             if (ctlRegion && thumbRegion && oldRegion && privData)
  324.             {
  325.                 diameter = CalcRounding(&(*me)->contrlRect);
  326.                 GetClip(oldRegion);
  327.                 CopyRect(&thumbRect, &tempRect);
  328.                 // InsetRect(&tempRect, -2,-2);
  329.                 OpenRgn();
  330.                     FrameRoundRect(&(*me)->contrlRect, diameter, diameter);
  331.                 CloseRgn(ctlRegion);
  332.                 OpenRgn();
  333.                     FrameRoundRect(&thumbRect, diameter, diameter);
  334.                 CloseRgn(thumbRegion);
  335.                 XorRgn(ctlRegion, thumbRegion, thumbRegion);
  336.                 SetClip(thumbRegion);
  337.                 CleanOldThumb(me, &thumbRect);
  338.                 SetClip(ctlRegion);
  339.                 DrawMyIndicator(me, &thumbRect);
  340.                 SetClip(oldRegion);
  341.             }
  342.             else // we had a memory allocation problem, draw whole thing
  343.             {
  344.                 EraseRect(&whiteRect);
  345.                 DrawMyFrame(me,&grayRect);
  346.                 DrawMyIndicator(me, &thumbRect);
  347.             }
  348.             if (thumbRegion) DisposeRgn(thumbRegion);
  349.             if (ctlRegion) DisposeRgn(ctlRegion);
  350.             if (oldRegion) DisposeRgn(oldRegion);
  351.             break;
  352.         default:
  353.         case inPageUp:
  354.         case inPageDown:
  355.         break;
  356.     }
  357.     if (privData)
  358.         (*privData)->oldValue = (*me)->contrlValue;
  359.     SetPenState(&oldState);
  360. }
  361. /*************** CleanOldThumb *************
  362. ***** We've gotten a message to draw the thumb, which
  363. ***** implies we have to eradicate the old thumb *******/
  364. void CleanOldThumb(ControlHandle me, Rect *thumbRect)
  365. {
  366.     PrivateHandle    privData;
  367.     short            oldValue, currValue;
  368.     short            diameter;
  369.     Rect            grayRect, ctlRect, oldThumb, whiteRect;
  370.     Boolean         upAndDown;
  371.     Pattern            grayPattern;
  372.     
  373.     privData = (PrivateHandle)(*me)->contrlData; // privData has already been tested
  374.     currValue = (*me)->contrlValue;
  375.     oldValue = (*privData)->oldValue;
  376.     
  377.     //if (currValue == oldValue) return;
  378.     
  379.     (*me)->contrlValue = oldValue;
  380.     CalcGrayRect(me, &grayRect, &whiteRect);
  381.     (*me)->contrlValue = currValue;
  382.     
  383.     CopyRect(&(*me)->contrlRect, &ctlRect);
  384.     diameter = CalcRounding(&ctlRect);
  385.     upAndDown = ((ctlRect.right - ctlRect.left) <= (ctlRect.bottom - ctlRect.top));
  386.     
  387.     CalcThumbRects(me, oldValue, &oldThumb);
  388.     GetIndPattern(grayPattern, 0, 1);// black
  389.     PenPat(&grayPattern);
  390.  
  391.     if (oldValue > currValue)
  392.     {
  393.         if (upAndDown)
  394.         {
  395.             oldThumb.bottom = thumbRect->bottom;
  396.         }
  397.         else
  398.         {
  399.             oldThumb.left = thumbRect->left;
  400.         }
  401.         FillRoundRect(&oldThumb, diameter, diameter, &grayPattern);
  402.     }
  403.     else
  404.     {
  405.         if (upAndDown)
  406.         {
  407.             oldThumb.top = thumbRect->top;
  408.         }
  409.         else
  410.         {
  411.             oldThumb.right = thumbRect->right;
  412.         }
  413.         EraseRoundRect(&oldThumb, diameter, diameter);
  414.     }
  415.     FrameRoundRect(&ctlRect, diameter, diameter);
  416. }
  417. /********** DrawMyIndicator ************
  418. ******* Draw the thumb, the thumbRect must be previously
  419. ******* calculated ******/
  420. void DrawMyIndicator(ControlHandle me, Rect *thumbRect)
  421. {
  422.     Rect        ctlRect;
  423.     Boolean     useColorQD, dimmed = FALSE;
  424.     RGBColor    newColor, oldColor;
  425.     Pattern        grayPattern;
  426.     Boolean        upAndDown;
  427.     short        diameter;
  428.     PrivateHandle    privData;
  429.     
  430.     privData = (PrivateHandle)(*me)->contrlData;
  431.     
  432.     if ((*me)->contrlMin >= (*me)->contrlMax) dimmed = TRUE;
  433.     if ((*me)->contrlHilite == 255) dimmed = TRUE;
  434.     
  435.     
  436.     if (!dimmed)
  437.     {
  438.         CopyRect(&(*me)->contrlRect, &ctlRect);
  439.         diameter = CalcRounding (&ctlRect);
  440.         
  441.     
  442.         // calculate the rectangles used in drawing
  443.         useColorQD = UseColorQD(me, thumbRect);
  444.         // start actual drawing
  445.         if(useColorQD && privData)
  446.         {
  447.             GetForeColor(&oldColor);
  448.             RGBForeColor(&(*privData)->thumbColor);    // real medium gray
  449.             GetIndPattern(grayPattern, 0, 1);// standard black for fill
  450.             FillRoundRect(thumbRect, diameter, diameter, &grayPattern);
  451.             RGBForeColor(&oldColor);
  452.         }
  453.         else
  454.         {
  455.             GetIndPattern(grayPattern, 0, 4);// standard gray for fill
  456.             FillRoundRect(thumbRect, diameter, diameter, &grayPattern);
  457.         }
  458.         FrameRoundRect(thumbRect, diameter, diameter);
  459.     }
  460. }
  461. /***************** CalcThumbRects ******
  462. **** should be CalcThumbRect, just figure what the bounding rect of
  463. *** the thumb should be given the value *******/
  464. void CalcThumbRects(ControlHandle me, short value, 
  465.         Rect *roundThumb)
  466. {
  467.     long    width, height, thumbLen;
  468.     Point    valuePoint;
  469.     Rect    ctlRect;
  470.     
  471.     CopyRect(&(*me)->contrlRect, &ctlRect);
  472.     CopyRect(&ctlRect, roundThumb);
  473.     
  474.     height = ctlRect.bottom - ctlRect.top;
  475.     width = ctlRect.right - ctlRect.left;
  476.     
  477.     MapValue2Point(me, value, &valuePoint);
  478.     thumbLen = CalcThumbLen(&ctlRect);
  479.     // calculate the rectangles used in drawing
  480.     if (height >= width)
  481.     {
  482.         roundThumb->top = valuePoint.v - thumbLen/2;
  483.         roundThumb->bottom = roundThumb->top+thumbLen;
  484.         
  485.     }
  486.     else
  487.     {
  488.         roundThumb->right = valuePoint.h + thumbLen/2;
  489.         roundThumb->left = roundThumb->right - thumbLen;
  490.     }
  491. }
  492. /********** CalcThumbLen *********
  493. **** figure how high or wide the thumb should be (given
  494. **** that some moron might have made the control too small ***/
  495. short CalcThumbLen(Rect *ctlRect)
  496. {
  497.     short    height, width;
  498.     short    result;
  499.     height = ctlRect->bottom - ctlRect->top;
  500.     width = ctlRect->right - ctlRect->left;
  501.     if (width > height)
  502.     {
  503.         result = (width > 20)?20:width;
  504.     }
  505.     else
  506.     {
  507.         result = (height > 20)?20:height;
  508.     }
  509.     return (result);
  510. }
  511. /********* DrawMyFrame **********
  512. ******* Draw the black portion of the control (pageup)
  513. ******* and frame the whole thing ********/
  514. void DrawMyFrame(ControlHandle me, Rect *grayRect)
  515. {    
  516.     Rect        ctlRect;
  517.     Boolean     useColorQD, dimmed = FALSE;
  518.     RGBColor    newColor, oldColor;
  519.     Pattern        grayPattern;
  520.     PrivateHandle    privData;
  521.     short         min, max, diameter;
  522.     privData = (PrivateHandle)(*me)->contrlData;
  523.     
  524.     CopyRect(&(*me)->contrlRect, &ctlRect);
  525.     useColorQD = UseColorQD(me, &ctlRect);
  526.     min = (*me)->contrlMin;
  527.     max = (*me)->contrlMax;
  528.     diameter = CalcRounding (&ctlRect);
  529.     if (min >= max) 
  530.     {
  531.         dimmed = TRUE;
  532.     }
  533.     if ((*me)->contrlHilite == 255) dimmed = TRUE;
  534.     
  535.     if (!dimmed)
  536.     {
  537.         GetIndPattern(grayPattern, 0, 1);// standard black for frame and top region
  538.         FillRoundRect(grayRect,diameter, diameter, &grayPattern);
  539.         PenPat(&grayPattern);
  540.     }
  541.     if(useColorQD && privData)
  542.     {
  543.         GetForeColor(&oldColor);
  544.         RGBForeColor(&(*privData)->frameColor);    
  545.         FrameRoundRect(&ctlRect, diameter, diameter);
  546.         RGBForeColor(&oldColor);
  547.     }
  548.     else
  549.         FrameRoundRect(&ctlRect, diameter, diameter);
  550. }
  551. /*********** CalcGrayRect
  552. ***** figure out the rectangle which enclose the pageup and pagedown
  553. ***** parts of the control (they meet in the middle of the thumb) ***/
  554. void    CalcGrayRect(ControlHandle me, Rect *grayRect, Rect *whiteRect)
  555. {
  556.     long    height, width, value, max, min;
  557.     Point    valuePoint;  
  558.     short    thumbLen, halfThumb;
  559.     
  560.     
  561.     value = (*me)->contrlValue;
  562.     min = (*me)->contrlMin;
  563.     max = (*me)->contrlMax;
  564.     if (value > max) // too big, who let this in?
  565.         value = max;
  566.     else if (value < min) // too small
  567.         value = min;
  568.     MapValue2Point(me,value, &valuePoint);
  569.     
  570.     CopyRect(&(*me)->contrlRect, grayRect);
  571.     CopyRect(grayRect, whiteRect);
  572.     thumbLen = CalcThumbLen(grayRect);
  573.     halfThumb = thumbLen /2;
  574.     width = grayRect->right - grayRect->left;
  575.     height = grayRect->bottom - grayRect->top;
  576.     if (width > height) // we are going side to side
  577.     {
  578.         grayRect->left = valuePoint.h - halfThumb;
  579.         whiteRect->right = valuePoint.h;
  580.     }
  581.     else
  582.     { // halfThumb is because quickdraw sort of bales out
  583.         // when round rects are small 
  584.         grayRect->bottom = valuePoint.v + halfThumb;
  585.         whiteRect->top = valuePoint.v;
  586.     }
  587. }
  588. /******* CalcRounding *******
  589. ****** are we big enough to use round rectangles 
  590. if so use 16 diameter rounding, if not use square corners ****/
  591. short CalcRounding(Rect *ctlRect)
  592. {
  593.     short    width, height;
  594.     width = ctlRect->right - ctlRect->left;
  595.     height = ctlRect->bottom - ctlRect->top;
  596.     if (width > height)
  597.     {
  598.         if (width > 64)
  599.             return (16);
  600.     }
  601.     else
  602.     {
  603.         if (height > 64)
  604.             return (16);
  605.     }
  606.     return (0);
  607. }
  608.  
  609. /******** InitMe ********
  610. ****** allocate my global memory, test for color and load color table
  611. ****** information ****/
  612. void InitMe(ControlHandle me)
  613. {
  614.     PrivateHandle    privDataH;
  615.     AuxCtlHandle        acHndl;
  616.     CCTabHandle        tableH;
  617.     short            tabLen;
  618.     RGBColor        *tempColor;
  619.     privDataH = (PrivateHandle)NewHandleClear(sizeof(Private));
  620.     if (privDataH)
  621.     {
  622.         if ((*privDataH)->useColorQD = TestForColor())
  623.         {// we are using color, find the highlight color
  624.             tempColor = &(*privDataH)->frameColor;
  625.             tempColor->red = tempColor->blue = tempColor->green = 0; // black
  626.             tempColor = &(*privDataH)->thumbColor; 
  627.             tempColor->blue = tempColor->green = tempColor->red = 30583; // gray
  628.             GetAuxCtl(me, &acHndl);
  629.             if (acHndl)
  630.             {
  631.                 tableH = (*acHndl)->acCTable;
  632.                 tabLen = (*tableH)->ctSize;
  633.                 while(tabLen >= 0)
  634.                 {
  635.                     if ((*tableH)->ctTable[tabLen].value == cFrameColor)
  636.                     {
  637.                         BlockMove(&(*tableH)->ctTable[tabLen].rgb, 
  638.                             &(*privDataH)->frameColor, sizeof(RGBColor));
  639.                     }
  640.                     /* else if ((*tableH)->ctTable[tabLen].value == cThumbColor)
  641.                     {
  642.                         BlockMove(&(*tableH)->ctTable[tabLen].rgb, 
  643.                             &(*privDataH)->thumbColor, sizeof(RGBColor));
  644.                     } */
  645.                     tabLen--;
  646.                 }
  647.             }
  648.         }
  649.         // we need to know if we can call GetDeviceList to tell whether 
  650.         // or not our control is on a deep color screen
  651.         (*privDataH)->devicesAvailable = TrapAvailable(0xAA29);
  652.         
  653.         (*privDataH)->oldValue = (*me)->contrlValue;
  654.     }
  655.     (*me)->contrlData = (Handle)privDataH;
  656. }
  657.  
  658.  
  659.